package com.huai.demo_test1.test1;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.joda.time.DateTime;

import java.io.*;
import java.util.*;
import java.util.function.Predicate;

import static org.junit.Assert.*;

public class Test {
    /**
     * 默认方法的工作原理：
     *  多重继承的行为方法。
     *  类胜于接口。如果继承链中有方法体或抽象方法声明，那么就可以忽略接口中定义的方法。
     *  子类胜于父类。如果一个接口继承了另一个接口，且两个接口都定义了一个默认方法，那么子类中定义的方法胜出。
     *  如果两条规则不适用。如果上面两条规则不适用，子类要么需要实现该方法，要么将该方法声明为抽象方法。
     */
    @org.junit.Test
    public void test() {
        Carriage carriage=new MusicalCarriage();
        carriage.rock();
        assertEquals("... from side to side", carriage.rock());
    }

    public static void main(String[] args) {
//        base64ToFile("/Users/huaixiaohuan/Downloads",
//                "ifp.txt"
//                , "ifp.zip");
        System.out.println(new DateTime());
        System.out.println(new Date());
    }

    public static void base64ToFile(String outFilePath, String name, String outFileName) {
        System.out.println("输出路径"+ outFilePath +","+ name + "," + outFileName );
        File file = null;
        //创建文件目录
        String filePath = outFilePath;
        File dir = new File(filePath);
        if (!dir.exists() && !dir.isDirectory()) {
            dir.mkdirs();
        }
        BufferedOutputStream bos = null;
        java.io.FileOutputStream fos = null;
        byte[] buffer = new byte[2048];
        try (InputStream inputStream1 = new FileInputStream(name)) {
            while (true) {
                int len = inputStream1.read(buffer);
                if (len == -1) {
                    break;
                }
            }
            byte[] bytes = Base64.getDecoder().decode(buffer);
            file = new File(filePath + "/" + outFileName);
            fos = new java.io.FileOutputStream(file);
            bos = new BufferedOutputStream(fos);
            bos.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @org.junit.Test
    public void testJukeBox() {
        Jukebox jukebox=new MusicalCarriage();
        jukebox.rock();
        assertEquals("... all over the world!", jukebox.rock());
    }

    /**
     * reduce 一个重点尚未提及：前面需要的又一个初始值，另一种变式则不需要有初始值。reduce方法返回一个Option对象。
        Optional 是为核心类库新设计的一个数据类型，用来替换 null 值。
     *
     */
    @org.junit.Test
    public void testOption(){
        Optional<String> a = Optional.of("a");
        assertEquals("a", a.get());

        Optional emptyOptional = Optional.empty();
        Optional alsoEmpty = Optional.ofNullable(null);
        assertFalse(emptyOptional.isPresent());
        // 例 4-22 中定义了变量 a
        assertTrue(a.isPresent());

        Optional empty = Optional.empty();
        Optional.ofNullable(null);
    }

    /**
     * 交换两个数的值  常用
     * @param array
     * @param i
     * @param j
     */
    @org.junit.Test
    public void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    /**
     * 交换两个数   加法实现
     * @param array
     * @param i
     * @param j
     */
    @org.junit.Test
    public void swap2(int[] array, int i, int j) {
        if (i != j) {
            array[i] = array[i] + array[j];
            array[j] = array[i] - array[j];    //等价替换：array[j]=(array[i]+array[j])-array[j]   ==> array[j]=array[i];
            array[i] = array[i] - array[j];    //等价替换：array[i]=(array[i]+array[j])-array[j]   ==> array[i]=array[i];
        }
    }

    /**
     * 交换两个数   减法实现
     * @param array
     * @param i
     * @param j
     */
    @org.junit.Test
    public void swap3(int[] array, int i, int j){
        if (i != j) {
            array[i] = array[i] - array[j];
            array[j] = array[i] + array[j];    //等价替换：array[j]=array[i]-array[j]+array[j]  ==> array[j]=array[i];
            array[i] = array[j] - array[i];    //等价替换：array[i]=array[j]-array[i]+array[j]  ==> array[i]=array[j];
        }
    }

    /**
     * 交换两个数，乘法实现
     * @param array
     * @param i
     * @param j
     */
    @org.junit.Test
    public void swap4(int[] array, int i, int j) {
        if (i != j) {
            array[i] = array[i] * array[j];
            array[j] = array[i] / array[j];
            array[i] = array[i] / array[j];
        }
    }

    /**   ????????
     * 逻辑运算符实现    &(and)、^(or)、|(not)
     * @param array
     * @param i
     * @param j
     */
    @org.junit.Test
    public void swap5(int[] array, int i, int j) {
        int temp = (array[i] & array[j]) ^ (array[i] | array[j]);   //  int temp =array[i]^array[j]
        array[i] = temp ^ array[i];         //等价于 array[i] ^ array[j] ^ array[i] ==> array[j];
        array[j] = temp ^ array[j];         //等价于 array[i] ^ array[j] ^ array[j] ==> array[i];
    }


}
